/**
 * Create by mzq
 * Description: 文件内容操作工具类
 * Date: 2025/1/24 10:58
 * Update: 2025/1/24 10:58
 */

// 添加文件缓存
const fileCache = {
    data: {}, // 缓存数据
    metadata: {}, // 文件元数据缓存
    maxSize: 50, // 最大缓存文件数
    lastAccess: {}, // 最后访问时间
    
    // 获取缓存
    get(path, type = 'data') {
        const cache = type === 'data' ? this.data : this.metadata;
        const result = cache[path];
        if (result) {
            this.lastAccess[path] = Date.now();
            return result;
        }
        return null;
    },
    
    // 设置缓存
    set(path, data, type = 'data') {
        const cache = type === 'data' ? this.data : this.metadata;
        
        // 如果缓存已满，清除最久未使用的项
        if (Object.keys(cache).length >= this.maxSize) {
            this.evictLRU(type);
        }
        
        cache[path] = data;
        this.lastAccess[path] = Date.now();
    },
    
    // 清除最久未使用的缓存项
    evictLRU(type = 'data') {
        const cache = type === 'data' ? this.data : this.metadata;
        let oldestPath = null;
        let oldestTime = Infinity;
        
        for (const path in cache) {
            if (this.lastAccess[path] < oldestTime) {
                oldestTime = this.lastAccess[path];
                oldestPath = path;
            }
        }
        
        if (oldestPath) {
            delete cache[oldestPath];
            console.log(`缓存清理: 移除 ${oldestPath}`);
        }
    },
    
    // 清除指定路径的缓存
    clear(path) {
        if (path) {
            delete this.data[path];
            delete this.metadata[path];
            delete this.lastAccess[path];
        } else {
            this.data = {};
            this.metadata = {};
            this.lastAccess = {};
        }
    }
};

/**
 * 智能保存 JSON 数据到文件（原子化写入不覆盖）
 *
 * ### 特性
 * - 🛡️ 原子化写入：通过临时文件避免写入中断导致数据损坏
 * - 🔄 格式自适应：自动处理 `{}` 和 `[{}]` 输入格式
 * - 📦 数据合并：始终将文件内容保持为标准 JSON 数组格式
 * - 🚦 异常隔离：自动修复损坏的JSON文件并保留有效数据
 *
 * @param {Object|Array} json - 要保存的JSON数据，支持对象或数组格式
 * @param {string} fileNamePath - 目标文件路径（含文件名）
 * @param {boolean} [replace=false] - 是否替换现有数据，true表示完全替换，false表示追加
 * @returns {Promise<boolean>} 返回Promise对象：
 * - 成功解析 `true`
 * - 失败拒绝携带错误对象 `{message: string, stack?: string}`
 */
export function writeJsonToFile(json, fileNamePath, replace = false) {
    const File = plus.android.importClass("java.io.File");
    const FileWriter = plus.android.importClass("java.io.FileWriter");
    const FileReader = plus.android.importClass("java.io.FileReader");
    const BufferedReader = plus.android.importClass("java.io.BufferedReader");

    // 生成纯数字ID
    const generateId = () => {
        const timestamp = new Date().getTime(); // 获取当前时间戳
        const randomNum = Math.floor(Math.random() * 10000); // 生成一个随机数
        return `${timestamp}${randomNum}`; // 组合成纯数字ID
    };

    // 获取当前时间的年月日时分秒格式
    const getCurrentTime = () => {
        const now = new Date();
        const year = now.getFullYear();
        const month = String(now.getMonth() + 1).padStart(2, '0');
        const day = String(now.getDate()).padStart(2, '0');
        const hours = String(now.getHours()).padStart(2, '0');
        const minutes = String(now.getMinutes()).padStart(2, '0');
        const seconds = String(now.getSeconds()).padStart(2, '0');
        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
    };

    // 安全读取现有文件内容
    const readExistingData = (file) => {
        try {
            const reader = new BufferedReader(new FileReader(file));
            const content = [];
            let line;
            while ((line = reader.readLine()) !== null) {
                content.push(line);
            }
            reader.close();
            return content.join('\n');
        } catch (e) {
            console.error("读取文件失败，重置数据:", e);
            return '[]'; // 返回空数组兜底
        }
    };

    // 规范输入数据并添加元数据
    const normalizeInput = (data) => {
        try {
            // 转换原始数据为数组
            const dataArray = Array.isArray(data)
                ? [...data]
                : (typeof data === 'object' ? [data] : []);

            // 为每个数据项添加元数据
            return dataArray.map(item => ({
                ...item,
                id: item.id || generateId(),     // 保留已有ID，否则生成新ID
                createData: item.createData || getCurrentTime() // 保留已有时间，否则生成新时间
            }));
        } catch (e) {
            throw new Error("无效的JSON格式: 必须为对象或数组");
        }
    };

    try {
        // 路径处理
        const dirPath = fileNamePath.substring(0, fileNamePath.lastIndexOf("/"));
        const dir = new File(dirPath);
        if (!dir.exists()) dir.mkdirs();

        const targetFile = new File(fileNamePath);
        let existingData = [];

        // 如果不是替换模式，则读取并解析已有数据
        if (!replace && targetFile.exists() && targetFile.length() > 0) {
            try {
                existingData = JSON.parse(readExistingData(targetFile));
                if (!Array.isArray(existingData)) {
                    console.warn("已有数据格式错误，重置为数组");
                    existingData = [];
                }
            } catch (e) {
                console.error("解析失败，重置数据:", e);
                existingData = [];
            }
        }

        // 处理新数据（自动添加id和createData）
        const processedData = normalizeInput(json);

        // ID冲突检测（增强唯一性保障）
        const existingIds = new Set(existingData.map(item => item.id));
        const newIds = new Set();

        for (const item of processedData) {
            if (existingIds.has(item.id) || newIds.has(item.id)) {
                console.warn(`检测到重复ID ${item.id}，重新生成...`);
                item.id = generateId(); // 强制生成新ID
            }
            newIds.add(item.id);
        }

        // 合并数据或直接使用新数据
        const finalData = replace ? processedData : [...existingData, ...processedData];

        // 原子化写入
        const tempFile = new File(fileNamePath + ".tmp");
        const writer = new FileWriter(tempFile);
        writer.write(JSON.stringify(finalData, null, 2));
        writer.close();

        // 替换原文件
        if (tempFile.renameTo(targetFile)) {
            console.log("数据更新成功:", fileNamePath);
            
            // 清除相关缓存
            fileCache.clear(fileNamePath);
            
            // 清除可能的字段过滤缓存
            const cacheKeyPrefix = fileNamePath + ":";
            for (const key in fileCache.data) {
                if (key.startsWith(cacheKeyPrefix)) {
                    fileCache.clear(key);
                }
            }
            
            return true;
        } else {
            throw new Error("文件重命名失败");
        }
    } catch (e) {
        console.error("操作失败:", e);
        return false;
    }
}

/**
 * 从本地文件读取并解析JSON内容（Android平台专用）
 * @param {string} fileNamePath - 文件绝对路径（示例格式：/storage/emulated/0/.../yourfile.txt）
 * @param {boolean} bypassCache - 是否绕过缓存
 * @returns {Object|string|null} - 返回解析后的JSON对象、原始字符串内容 或 null（文件不存在时）
 */
export function readJsonFromFile(fileNamePath, bypassCache = false) {
    // 检查缓存
    if (!bypassCache) {
        const cachedData = fileCache.get(fileNamePath);
        if (cachedData) {
            console.log(`缓存命中: ${fileNamePath}`);
            return cachedData;
        }
    }
    
    // 导入所需的Java类
    const File = plus.android.importClass("java.io.File");
    const BufferedReader = plus.android.importClass("java.io.BufferedReader");
    const FileReader = plus.android.importClass("java.io.FileReader");
    const StringBuilder = plus.android.importClass("java.lang.StringBuilder");

    try {
        const file = new File(fileNamePath);

        // 检查文件是否存在
        if (!file.exists()) {
            console.log("文件不存在:", fileNamePath);
            return null;
        }

        // 读取文件内容，使用StringBuilder提高性能
        const reader = new BufferedReader(new FileReader(file), 8192); // 8KB缓冲区
        const sb = new StringBuilder(Math.max(1024, Math.min(file.length(), 16384))); // 预分配合适大小
        let line;

        while ((line = reader.readLine()) !== null) {
            sb.append(line);
        }
        reader.close();
        
        const content = String(sb.toString());

        // 尝试解析JSON
        try {
            const jsonData = JSON.parse(content);
            console.log("文件读取成功:", fileNamePath);
            
            // 缓存结果
            fileCache.set(fileNamePath, jsonData);
            
            return jsonData;
        } catch (parseError) {
            console.error("JSON解析失败:", parseError);
            return content; // 如果不是JSON格式，返回原始内容
        }
    } catch (e) {
        console.error("文件读取失败:", e);
        return null;
    }
}


/**
 * 根据ID从JSON文件中删除指定数据项（Android平台专用）
 * @param {string|number} targetId - 要删除的数据项ID
 * @param {string} fileNamePath - 文件绝对路径
 * @returns {boolean} - 是否成功执行删除操作
 */
export function deleteById(targetId, fileNamePath) {
    const File = plus.android.importClass("java.io.File");
    const FileWriter = plus.android.importClass("java.io.FileWriter");
    const FileReader = plus.android.importClass("java.io.FileReader");
    const BufferedReader = plus.android.importClass("java.io.BufferedReader");

    try {
        const targetFile = new File(fileNamePath);

        // 检查文件是否存在
        if (!targetFile.exists()) {
            console.warn("目标文件不存在:", fileNamePath);
            return false;
        }

        // 安全读取现有数据
        let existingData = [];
        try {
            const rawContent = readExistingData(targetFile); // 复用你的读取方法
            existingData = JSON.parse(rawContent);
            if (!Array.isArray(existingData)) {
                console.warn("数据格式错误，重置为数组");
                existingData = [];
            }
        } catch (e) {
            console.error("数据解析失败:", e);
            return false;
        }

        // 深拷贝原始数据用于修改
        const originalLength = existingData.length;
        const updatedData = JSON.parse(JSON.stringify(existingData))
            .filter(item => {
                // 严格类型比较（数字和字符串ID兼容）
                return String(item.id) !== String(targetId);
            });

        // 检查是否实际删除了数据
        if (updatedData.length === originalLength) {
            console.warn("未找到匹配ID的数据:", targetId);
            return false;
        }

        // 原子化写入更新后的数据
        const tempFile = new File(fileNamePath + ".tmp");
        const writer = new FileWriter(tempFile);
        writer.write(JSON.stringify(updatedData, null, 2));
        writer.close();

        // 替换原文件
        if (tempFile.renameTo(targetFile)) {
            console.log(`成功删除ID为 ${targetId} 的数据`);
            
            // 清除相关缓存
            fileCache.clear(fileNamePath);
            
            // 清除可能的字段过滤缓存
            const cacheKeyPrefix = fileNamePath + ":";
            for (const key in fileCache.data) {
                if (key.startsWith(cacheKeyPrefix)) {
                    fileCache.clear(key);
                }
            }
            
            // 清除患者文件缓存
            const patientFile = `/sdcard/test/${targetId}.json`;
            fileCache.clear(patientFile);
            
            return true;
        } else {
            throw new Error("文件替换失败");
        }
    } catch (e) {
        console.error("删除操作失败:", e);
        return false;
    }

    // 复用你现有的安全读取方法
    function readExistingData(file) {
        try {
            const reader = new BufferedReader(new FileReader(file));
            const content = [];
            let line;
            while ((line = reader.readLine()) !== null) {
                content.push(line);
            }
            reader.close();
            return content.join('\n');
        } catch (e) {
            console.error("读取文件失败:", e);
            return '[]';
        }
    }
}

/**
 * 根据ID数组批量删除指定数据项（Android平台专用）
 * @param idsArray
 * @param fileNamePath
 * @returns {*}
 */
function deleteByIds(idsArray, fileNamePath) {
    return idsArray.every(id => deleteById(id, fileNamePath));
}

/**
 * 根据ID更新JSON文件中的指定数据项
 * @param {string|number} id - 要更新的数据项唯一标识（不可修改）
 * @param {Object} updateData - 需要更新的数据内容（不能包含id字段）
 * @param {string} fileNamePath - 目标JSON文件完整路径
 * @returns {boolean} 更新是否成功
 */
export function updateJsonById(id, updateData, fileNamePath) {
    const File = plus.android.importClass("java.io.File");
    const FileWriter = plus.android.importClass("java.io.FileWriter");
    const FileReader = plus.android.importClass("java.io.FileReader");
    const BufferedReader = plus.android.importClass("java.io.BufferedReader");

    // 复用已有的时间获取方法
    const getCurrentTime = () => {
        const now = new Date();
        const year = now.getFullYear();
        const month = String(now.getMonth() + 1).padStart(2, '0');
        const day = String(now.getDate()).padStart(2, '0');
        const hours = String(now.getHours()).padStart(2, '0');
        const minutes = String(now.getMinutes()).padStart(2, '0');
        const seconds = String(now.getSeconds()).padStart(2, '0');
        return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
    };

    // 复用已有的安全读取方法
    const readExistingData = (file) => {
        try {
            const reader = new BufferedReader(new FileReader(file));
            const content = [];
            let line;
            while ((line = reader.readLine()) !== null) {
                content.push(line);
            }
            reader.close();
            return content.join('\n');
        } catch (e) {
            console.error("读取文件失败:", e);
            return '[]';
        }
    };

    try {
        const targetFile = new File(fileNamePath);
        if (!targetFile.exists()) {
            console.warn("文件不存在");
            return false;
        }

        // 读取并解析数据
        let existingData;
        try {
            existingData = JSON.parse(readExistingData(targetFile));
            if (!Array.isArray(existingData)) {
                console.warn("数据格式错误，重置为数组");
                existingData = [];
            }
        } catch (e) {
            console.error("解析数据失败:", e);
            return false;
        }

        // 查找需要修改的条目
        let found = false;
        const updatedData = existingData.map(item => {
            if (String(item.id) === String(id)) {
                found = true;
                // 保留原始创建时间，添加修改时间
                return {
                    ...item,
                    ...updateData,
                    id: item.id, // 防止ID被修改
                    createData: item.createData, // 保留原始创建时间
                    modifyData: getCurrentTime() // 添加修改时间
                };
            }
            return item;
        });

        if (!found) {
            console.warn("未找到匹配ID的数据");
            return false;
        }

        // 原子化写入
        const tempFile = new File(fileNamePath + ".tmp");
        const writer = new FileWriter(tempFile);
        writer.write(JSON.stringify(updatedData, null, 2));
        writer.close();

        // 替换原文件
        if (tempFile.renameTo(targetFile)) {
            console.log("数据更新成功:", fileNamePath);
            
            // 清除相关缓存
            fileCache.clear(fileNamePath);
            
            // 清除可能的字段过滤缓存
            const cacheKeyPrefix = fileNamePath + ":";
            for (const key in fileCache.data) {
                if (key.startsWith(cacheKeyPrefix)) {
                    fileCache.clear(key);
                }
            }
            
            // 清除患者文件缓存
            const patientFile = `/sdcard/test/${id}.json`;
            fileCache.clear(patientFile);
            
            return true;
        } else {
            throw new Error("文件重命名失败");
        }
    } catch (e) {
        console.error("更新操作失败:", e);
        return false;
    }
}

/**
 * 高效读取大型JSON文件（优化版本）
 * 使用流式读取和部分解析技术，适用于大型JSON文件
 * 
 * @param {string} fileNamePath - 文件绝对路径
 * @param {Object} options - 配置选项
 * @param {boolean} [options.metadataOnly=false] - 是否只读取元数据（id, name等基本信息）
 * @param {Array<string>} [options.fields] - 需要读取的字段列表，如果metadataOnly为true，则忽略此参数
 * @param {boolean} [options.bypassCache=false] - 是否绕过缓存
 * @returns {Object|null} - 返回解析后的JSON对象或null（文件不存在时）
 */
export function readLargeJsonFile(fileNamePath, options = {}) {
    const { metadataOnly = false, fields = [], bypassCache = false } = options;
    
    // 生成缓存键
    const cacheType = metadataOnly ? 'metadata' : 'data';
    const cacheKey = fields.length > 0 ? `${fileNamePath}:${fields.join(',')}` : fileNamePath;
    
    // 检查缓存
    if (!bypassCache) {
        const cachedData = fileCache.get(cacheKey, cacheType);
        if (cachedData) {
            console.log(`缓存命中: ${cacheKey}`);
            return cachedData;
        }
    }
    
    // 导入所需的Java类
    const File = plus.android.importClass("java.io.File");
    const FileInputStream = plus.android.importClass("java.io.FileInputStream");
    const InputStreamReader = plus.android.importClass("java.io.InputStreamReader");
    const BufferedReader = plus.android.importClass("java.io.BufferedReader");
    const JSONObject = plus.android.importClass("org.json.JSONObject");
    const JSONArray = plus.android.importClass("org.json.JSONArray");
    
    try {
        const file = new File(fileNamePath);
        
        // 检查文件是否存在
        if (!file.exists()) {
            console.log("文件不存在:", fileNamePath);
            return null;
        }
        
        // 如果文件小于1MB，使用常规方法读取
        if (file.length() < 1024 * 1024) {
            const result = readJsonFromFile(fileNamePath, bypassCache);
            
            // 如果需要元数据过滤，处理结果
            if (result && metadataOnly) {
                const processedResult = Array.isArray(result) 
                    ? result.map(item => extractMetadata(item))
                    : extractMetadata(result);
                
                // 缓存处理后的结果
                fileCache.set(cacheKey, processedResult, cacheType);
                
                return processedResult;
            } else if (result && fields.length > 0) {
                // 如果需要字段过滤
                const processedResult = Array.isArray(result)
                    ? result.map(item => extractFields(item, fields))
                    : extractFields(result, fields);
                
                // 缓存处理后的结果
                fileCache.set(cacheKey, processedResult, cacheType);
                
                return processedResult;
            }
            
            return result;
        }
        
        // 对于大文件，使用流式读取
        const fis = new FileInputStream(file);
        const isr = new InputStreamReader(fis, "UTF-8");
        const reader = new BufferedReader(isr, 32768); // 增大缓冲区到32KB
        
        // 读取文件的前128个字符来确定是对象还是数组
        const charBuffer = plus.android.newArray("char", 128);
        reader.mark(129);
        reader.read(charBuffer, 0, 128);
        reader.reset();
        
        const startChars = String(plus.android.newString(charBuffer)).trim();
        const isArray = startChars.startsWith("[");
        
        let result;
        
        // 使用更高效的方式读取文件内容
        const content = readFullContent(reader);
        
        if (isArray) {
            // 处理JSON数组
            const jsonArray = new JSONArray(content);
            result = [];
            
            for (let i = 0; i < jsonArray.length(); i++) {
                const jsonObject = jsonArray.getJSONObject(i);
                
                if (metadataOnly) {
                    // 只提取元数据
                    result.push(extractMetadata(jsonObjectToJs(jsonObject)));
                } else if (fields && fields.length > 0) {
                    // 提取指定字段
                    result.push(extractFields(jsonObjectToJs(jsonObject), fields));
                } else {
                    // 提取完整对象
                    result.push(jsonObjectToJs(jsonObject));
                }
            }
        } else {
            // 处理单个JSON对象
            const jsonObject = new JSONObject(content);
            
            if (metadataOnly) {
                result = extractMetadata(jsonObjectToJs(jsonObject));
            } else if (fields && fields.length > 0) {
                result = extractFields(jsonObjectToJs(jsonObject), fields);
            } else {
                result = jsonObjectToJs(jsonObject);
            }
        }
        
        // 关闭资源
        reader.close();
        isr.close();
        fis.close();
        
        // 缓存结果
        fileCache.set(cacheKey, result, cacheType);
        
        return result;
    } catch (e) {
        console.error("大文件读取失败:", e);
        // 失败后尝试使用常规方法读取
        return readJsonFromFile(fileNamePath, bypassCache);
    }
    
    // 辅助函数：读取完整内容 - 优化版本
    function readFullContent(reader) {
        const StringBuilder = plus.android.importClass("java.lang.StringBuilder");
        const sb = new StringBuilder(32768); // 预分配32KB
        const buffer = plus.android.newArray("char", 8192); // 增大读取缓冲区到8KB
        let charsRead;
        
        while ((charsRead = reader.read(buffer, 0, 8192)) != -1) {
            sb.append(buffer, 0, charsRead);
        }
        
        return String(sb.toString());
    }
    
    // 辅助函数：将JSONObject转换为JS对象
    function jsonObjectToJs(jsonObject) {
        return JSON.parse(String(jsonObject.toString()));
    }
    
    // 辅助函数：提取元数据
    function extractMetadata(item) {
        return {
            id: item.id,
            name: item.name || '',
            sex: item.sex || '',
            age: item.age || '',
            admissionNumber: item.admissionNumber || '',
            createData: item.createData || item.createTime || '',
            operator: item.operator || '',
            // 添加必要的脑电数据字段
            leftBrainImpedance: item.leftBrainImpedance,
            rightBrainImpedance: item.rightBrainImpedance,
            allBrainImpedance: item.allBrainImpedance,
            stabilityWholeBrain: item.stabilityWholeBrain
        };
    }
    
    // 辅助函数：提取指定字段
    function extractFields(item, fields) {
        const result = {};
        fields.forEach(field => {
            if (item.hasOwnProperty(field)) {
                result[field] = item[field];
            }
        });
        return result;
    }
}

/**
 * 创建或更新患者索引文件
 * 索引文件包含所有患者的基本信息，用于快速加载患者列表
 * 
 * @param {string} indexFilePath - 索引文件路径
 * @param {string} patientDataDir - 患者数据目录
 * @returns {Promise<boolean>} - 是否成功创建或更新索引
 */
export async function createOrUpdatePatientIndex(indexFilePath, patientDataDir = '/sdcard/test') {
    const File = plus.android.importClass("java.io.File");
    const FileWriter = plus.android.importClass("java.io.FileWriter");
    
    try {
        // 创建索引文件目录
        const dirPath = indexFilePath.substring(0, indexFilePath.lastIndexOf("/"));
        const dir = new File(dirPath);
        if (!dir.exists()) dir.mkdirs();
        
        // 读取患者ID文件
        const patientIdsFile = `${patientDataDir}/patient_ids.json`;
        const patientIdsData = readLargeJsonFile(patientIdsFile) || [];
        
        // 将数据转换为数组格式
        const patientIds = Array.isArray(patientIdsData) ? patientIdsData : [patientIdsData];
        
        // 过滤掉无效的ID
        const validPatientIds = patientIds.filter(item => item && item.id);
        
        console.log(`开始为 ${validPatientIds.length} 个患者创建索引`);
        
        // 批量处理患者数据
        const batchSize = 20;
        const patientIndex = [];
        
        for (let i = 0; i < validPatientIds.length; i += batchSize) {
            const batch = validPatientIds.slice(i, i + batchSize);
            
            // 并行处理当前批次
            const batchPromises = batch.map(async (idObj) => {
                try {
                    const patientId = idObj.id;
                    const patientReportFile = `${patientDataDir}/${patientId}.json`;
                    
                    // 只读取元数据
                    const patientReport = readLargeJsonFile(patientReportFile, { metadataOnly: true });
                    
                    if (patientReport) {
                        // 如果是数组，取第一个元素
                        const metadata = Array.isArray(patientReport) ? patientReport[0] : patientReport;
                        
                        // 验证数据完整性，确保包含必要的脑电数据
                        const requiredFields = ['leftBrainImpedance', 'rightBrainImpedance', 'allBrainImpedance', 'stabilityWholeBrain'];
                        const hasCompleteData = requiredFields.every(field => metadata && metadata[field]);
                        
                        if (!hasCompleteData) {
                            console.log(`患者 ${patientId} 数据不完整，缺少必要的脑电数据字段，从索引中排除`);
                            return null;
                        }
                        
                        // 返回索引项
                        return {
                            id: metadata.id,
                            name: metadata.name || '',
                            sex: metadata.sex || '',
                            age: metadata.age || '',
                            admissionNumber: metadata.admissionNumber || '',
                            createData: metadata.createData || metadata.createTime || '',
                            operator: metadata.operator || '',
                            filePath: patientReportFile,
                            fileSize: new File(patientReportFile).length()
                        };
                    }
                    return null;
                } catch (error) {
                    console.error(`处理患者 ${idObj.id} 索引失败:`, error);
                    return null;
                }
            });
            
            // 等待当前批次处理完成
            const results = await Promise.all(batchPromises);
            
            // 过滤掉无效结果并添加到索引
            patientIndex.push(...results.filter(result => result !== null));
            
            console.log(`已处理 ${Math.min(i + batchSize, validPatientIds.length)} / ${validPatientIds.length} 个患者`);
        }
        
        // 按创建时间降序排序
        patientIndex.sort((a, b) => {
            const dateA = new Date(a.createData || 0);
            const dateB = new Date(b.createData || 0);
            return dateB - dateA;
        });
        
        // 写入索引文件
        const tempFile = new File(indexFilePath + ".tmp");
        const writer = new FileWriter(tempFile);
        writer.write(JSON.stringify(patientIndex, null, 2));
        writer.close();
        
        // 替换原文件
        const targetFile = new File(indexFilePath);
        if (tempFile.renameTo(targetFile)) {
            console.log(`成功创建索引文件，包含 ${patientIndex.length} 个患者`);
            return true;
        } else {
            throw new Error("索引文件重命名失败");
        }
    } catch (error) {
        console.error("创建患者索引失败:", error);
        return false;
    }
}

/**
 * 从索引文件加载患者列表
 * 
 * @param {string} indexFilePath - 索引文件路径
 * @param {boolean} forceRefresh - 是否强制刷新索引
 * @returns {Promise<Array>} - 患者列表
 */
export async function loadPatientsFromIndex(indexFilePath, forceRefresh = false) {
    const File = plus.android.importClass("java.io.File");
    
    try {
        const indexFile = new File(indexFilePath);
        
        // 如果索引文件不存在或需要强制刷新，则创建索引
        if (!indexFile.exists() || forceRefresh) {
            console.log("索引文件不存在或需要刷新，开始创建索引");
            const created = await createOrUpdatePatientIndex(indexFilePath);
            if (!created) {
                console.error("创建索引失败");
                return [];
            }
        }
        
        // 读取索引文件
        const patientIndex = readLargeJsonFile(indexFilePath) || [];
        
        console.log(`从索引加载了 ${patientIndex.length} 个患者`);
        return patientIndex;
    } catch (error) {
        console.error("从索引加载患者失败:", error);
        return [];
    }
}
